home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume7 / remtape < prev    next >
Encoding:
Internet Message Format  |  1986-12-16  |  28.5 KB
  1. Subject:  v07i091:  Remote magtape library for 4.3BSD
  2. Newsgroups: mod.sources
  3. Approved: mirror!rs
  4.  
  5. Submitted by: Arnold D. Robbins <linus!gatech!emoryu1!arnold>
  6. Mod.sources: Volume 7, Issue 91
  7. Archive-name: remtape
  8.  
  9. #! /bin/sh
  10. # This is a shell archive, meaning:
  11. # 1. Remove everything above the #! /bin/sh line.
  12. # 2. Save the resulting text in a file.
  13. # 3. Execute the file with /bin/sh (not csh) to create the files:
  14. #    README
  15. #    Makefile
  16. #    rmt.h
  17. #    rmtlib.c
  18. #    rmtops.3
  19. #    dd.1.patch
  20. #    dd.c.patch
  21. #    tar.1.patch
  22. #    tar.c.patch
  23. export PATH; PATH=/bin:$PATH
  24. echo shar: extracting "'README'" '(592 characters)'
  25. if test -f 'README'
  26. then
  27.     echo shar: will not over-write existing file "'README'"
  28. else
  29. cat << \SHAR_EOF > 'README'
  30. README
  31.  
  32. This is the remote mag tape library for 4.3 BSD. It is almost unchanged
  33. from the 4.2 version. However, I am sending the whole thing, since the first
  34. one is in the archives as an initial submission plus a patch, and it is
  35. small enough to be reposted again from scratch.
  36.  
  37. Besides the remote mag tape library (-lrmt) itself, I am including patches
  38. to tar, dd, and their man pages. I have used RCS this time around, therefore
  39. "your line numbers may vary". Patch should be able to handle it, though.
  40.  
  41. Enjoy,
  42.  
  43. Arnold Robbins
  44. Emory University Computing Center
  45. { akgua, gatech }!emory!arnold
  46. SHAR_EOF
  47. fi # end of overwriting check
  48. echo shar: extracting "'Makefile'" '(421 characters)'
  49. if test -f 'Makefile'
  50. then
  51.     echo shar: will not over-write existing file "'Makefile'"
  52. else
  53. cat << \SHAR_EOF > 'Makefile'
  54. #
  55. # $Header: Makefile,v 1.1 86/10/09 16:42:13 root Locked $
  56. #
  57. # $Log:    Makefile,v $
  58. # Revision 1.1  86/10/09  16:42:13  root
  59. # Initial revision
  60. # 
  61. #
  62. # Makefile for rmtlib
  63.  
  64. CFLAGS= -O
  65. SRC= rmtlib.c
  66. DOC= rmtops.3
  67.  
  68. MANSEC=3
  69. DEST= /usr/lib
  70.  
  71. librmt.a: rmtlib.o
  72.     ar rv librmt.a rmtlib.o
  73.  
  74. install: librmt.a
  75.     cp librmt.a /usr/lib
  76.     ranlib /usr/lib/librmt.a
  77.     cp $(DOC) /usr/man/man$(MANSEC)/rmtops.$(MANSEC)
  78.  
  79. clean:
  80.     rm -f rmtlib.o
  81. SHAR_EOF
  82. fi # end of overwriting check
  83. echo shar: extracting "'rmt.h'" '(1056 characters)'
  84. if test -f 'rmt.h'
  85. then
  86.     echo shar: will not over-write existing file "'rmt.h'"
  87. else
  88. cat << \SHAR_EOF > 'rmt.h'
  89. /*
  90.  * $Header: rmt.h,v 1.1 86/10/09 16:17:20 root Locked $
  91.  *
  92.  * $Log:    rmt.h,v $
  93.  * Revision 1.1  86/10/09  16:17:20  root
  94.  * Initial revision
  95.  * 
  96.  */
  97.  
  98. /*
  99.  *    rmt.h
  100.  *
  101.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  102.  *    The preprocessor can be used to remap these the rmtopen(), etc
  103.  *    thus minimizing source changes.
  104.  *
  105.  *    This file must be included before <sys/stat.h>, since it redefines
  106.  *    stat to be rmtstat, so that struct stat xyzzy; declarations work
  107.  *    properly.
  108.  *
  109.  *    -- Fred Fish (w/some changes by Arnold Robbins)
  110.  */
  111.  
  112.  
  113. #ifndef access        /* avoid multiple redefinition */
  114. #ifndef lint        /* in this case what lint doesn't know won't hurt it */
  115. #define access rmtaccess
  116. #define close rmtclose
  117. #define creat rmtcreat
  118. #define dup rmtdup
  119. #define fcntl rmtfcntl
  120. #define fstat rmtfstat
  121. #define ioctl rmtioctl
  122. #define isatty rmtisatty
  123. #define lseek rmtlseek
  124. #define lstat rmtlstat
  125. #define open rmtopen
  126. #define read rmtread
  127. #define stat rmtstat
  128. #define write rmtwrite
  129.  
  130. extern long rmtlseek ();    /* all the rest are int's */
  131. #endif
  132. #endif
  133. SHAR_EOF
  134. fi # end of overwriting check
  135. echo shar: extracting "'rmtlib.c'" '(14258 characters)'
  136. if test -f 'rmtlib.c'
  137. then
  138.     echo shar: will not over-write existing file "'rmtlib.c'"
  139. else
  140. cat << \SHAR_EOF > 'rmtlib.c'
  141. #ifndef lint
  142. static char *RCSid = "$Header: rmtlib.c,v 1.2 86/10/09 16:38:53 root Locked $";
  143. #endif
  144.  
  145. /*
  146.  * $Log:    rmtlib.c,v $
  147.  * Revision 1.2  86/10/09  16:38:53  root
  148.  * Changed to reflect 4.3BSD rcp syntax. ADR.
  149.  * 
  150.  * Revision 1.1  86/10/09  16:17:35  root
  151.  * Initial revision
  152.  * 
  153.  */
  154.  
  155. /*
  156.  *    rmt --- remote tape emulator subroutines
  157.  *
  158.  *    Originally written by Jeff Lee, modified some by Arnold Robbins
  159.  *
  160.  *    WARNING:  The man page rmt(8) for /etc/rmt documents the remote mag
  161.  *    tape protocol which rdump and rrestore use.  Unfortunately, the man
  162.  *    page is *WRONG*.  The author of the routines I'm including originally
  163.  *    wrote his code just based on the man page, and it didn't work, so he
  164.  *    went to the rdump source to figure out why.  The only thing he had to
  165.  *    change was to check for the 'F' return code in addition to the 'E',
  166.  *    and to separate the various arguments with \n instead of a space.  I
  167.  *    personally don't think that this is much of a problem, but I wanted to
  168.  *    point it out.
  169.  *    -- Arnold Robbins
  170.  *
  171.  *    Redone as a library that can replace open, read, write, etc, by
  172.  *    Fred Fish, with some additional work by Arnold Robbins.
  173.  */
  174.  
  175. /*
  176.  *    MAXUNIT --- Maximum number of remote tape file units
  177.  *
  178.  *    READ --- Return the number of the read side file descriptor
  179.  *    WRITE --- Return the number of the write side file descriptor
  180.  */
  181.  
  182. #define RMTIOCTL    1
  183.  
  184. #include <stdio.h>
  185. #include <signal.h>
  186. #include <sys/types.h>
  187.  
  188. #ifdef RMTIOCTL
  189. #include <sys/ioctl.h>
  190. #include <sys/mtio.h>
  191. #endif
  192.  
  193. #include <errno.h>
  194. #include <setjmp.h>
  195. #include <sys/stat.h>
  196.  
  197. #define BUFMAGIC    64    /* a magic number for buffer sizes */
  198. #define MAXUNIT    4
  199.  
  200. #define READ(fd)    (Ctp[fd][0])
  201. #define WRITE(fd)    (Ptc[fd][1])
  202.  
  203. static int Ctp[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  204. static int Ptc[MAXUNIT][2] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  205.  
  206. static jmp_buf Jmpbuf;
  207. extern int errno;
  208.  
  209. /*
  210.  *    abort --- close off a remote tape connection
  211.  */
  212.  
  213. static void abort(fildes)
  214. int fildes;
  215. {
  216.     close(READ(fildes));
  217.     close(WRITE(fildes));
  218.     READ(fildes) = -1;
  219.     WRITE(fildes) = -1;
  220. }
  221.  
  222.  
  223.  
  224. /*
  225.  *    command --- attempt to perform a remote tape command
  226.  */
  227.  
  228. static int command(fildes, buf)
  229. int fildes;
  230. char *buf;
  231. {
  232.     register int blen;
  233.     int (*pstat)();
  234.  
  235. /*
  236.  *    save current pipe status and try to make the request
  237.  */
  238.  
  239.     blen = strlen(buf);
  240.     pstat = signal(SIGPIPE, SIG_IGN);
  241.     if (write(WRITE(fildes), buf, blen) == blen)
  242.     {
  243.         signal(SIGPIPE, pstat);
  244.         return(0);
  245.     }
  246.  
  247. /*
  248.  *    something went wrong. close down and go home
  249.  */
  250.  
  251.     signal(SIGPIPE, pstat);
  252.     abort(fildes);
  253.  
  254.     errno = EIO;
  255.     return(-1);
  256. }
  257.  
  258.  
  259.  
  260. /*
  261.  *    status --- retrieve the status from the pipe
  262.  */
  263.  
  264. static int status(fildes)
  265. int fildes;
  266. {
  267.     int i;
  268.     char c, *cp;
  269.     char buffer[BUFMAGIC];
  270.  
  271. /*
  272.  *    read the reply command line
  273.  */
  274.  
  275.     for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++)
  276.     {
  277.         if (read(READ(fildes), cp, 1) != 1)
  278.         {
  279.             abort(fildes);
  280.             errno = EIO;
  281.             return(-1);
  282.         }
  283.         if (*cp == '\n')
  284.         {
  285.             *cp = 0;
  286.             break;
  287.         }
  288.     }
  289.  
  290.     if (i == BUFMAGIC)
  291.     {
  292.         abort(fildes);
  293.         errno = EIO;
  294.         return(-1);
  295.     }
  296.  
  297. /*
  298.  *    check the return status
  299.  */
  300.  
  301.     for (cp = buffer; *cp; cp++)
  302.         if (*cp != ' ')
  303.             break;
  304.  
  305.     if (*cp == 'E' || *cp == 'F')
  306.     {
  307.         errno = atoi(cp + 1);
  308.         while (read(READ(fildes), &c, 1) == 1)
  309.             if (c == '\n')
  310.                 break;
  311.  
  312.         if (*cp == 'F')
  313.             abort(fildes);
  314.  
  315.         return(-1);
  316.     }
  317.  
  318. /*
  319.  *    check for mis-synced pipes
  320.  */
  321.  
  322.     if (*cp != 'A')
  323.     {
  324.         abort(fildes);
  325.         errno = EIO;
  326.         return(-1);
  327.     }
  328.  
  329.     return(atoi(cp + 1));
  330. }
  331.  
  332.  
  333.  
  334. /*
  335.  *    _rmt_open --- open a magtape device on system specified, as given user
  336.  *
  337.  *    file name has the form system[.user]:/dev/????
  338.  */
  339.  
  340. #define MAXHOSTLEN    257    /* BSD allows very long host names... */
  341.  
  342. static int _rmt_open (path, oflag, mode)
  343. char *path;
  344. int oflag;
  345. int mode;
  346. {
  347.     int i, rc;
  348.     char buffer[BUFMAGIC];
  349.     char system[MAXHOSTLEN];
  350.     char device[BUFMAGIC];
  351.     char login[BUFMAGIC];
  352.     char *sys, *dev, *user;
  353.  
  354.     sys = system;
  355.     dev = device;
  356.     user = login;
  357.  
  358. /*
  359.  *    first, find an open pair of file descriptors
  360.  */
  361.  
  362.     for (i = 0; i < MAXUNIT; i++)
  363.         if (READ(i) == -1 && WRITE(i) == -1)
  364.             break;
  365.  
  366.     if (i == MAXUNIT)
  367.     {
  368.         errno = EMFILE;
  369.         return(-1);
  370.     }
  371.  
  372. /*
  373.  *    pull apart system and device, and optional user
  374.  *    don't munge original string
  375.  *    handle both old host.person and new person@site notations
  376.  */
  377.     while (*path != '@' && *path != '.' && *path != ':') {
  378.         *sys++ = *path++;
  379.     }
  380.     *sys = '\0';
  381.     path++;
  382.  
  383.     if (*(path - 1) == '@')
  384.     {
  385.         (void) strcpy (user, sys);    /* saw user part of user@host */
  386.         sys = system;            /* start over */
  387.         while (*path != ':') {
  388.             *sys++ = *path++;
  389.         }
  390.         *sys = '\0';
  391.         path++;
  392.     }
  393.     else if (*(path - 1) == '.')
  394.     {
  395.         while (*path != ':') {
  396.             *user++ = *path++;
  397.         }
  398.         *user = '\0';
  399.         path++;
  400.     }
  401.     else
  402.         *user = '\0';
  403.  
  404.     while (*path) {
  405.         *dev++ = *path++;
  406.     }
  407.     *dev = '\0';
  408.  
  409. /*
  410.  *    setup the pipes for the 'rsh' command and fork
  411.  */
  412.  
  413.     if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1)
  414.         return(-1);
  415.  
  416.     if ((rc = fork()) == -1)
  417.         return(-1);
  418.  
  419.     if (rc == 0)
  420.     {
  421.         close(0);
  422.         dup(Ptc[i][0]);
  423.         close(Ptc[i][0]); close(Ptc[i][1]);
  424.         close(1);
  425.         dup(Ctp[i][1]);
  426.         close(Ctp[i][0]); close(Ctp[i][1]);
  427.         (void) setuid (getuid ());
  428.         (void) setgid (getgid ());
  429.         if (*user)
  430.         {
  431.             execl("/usr/ucb/rsh", "rsh", system, "-l", login,
  432.                 "/etc/rmt", (char *) 0);
  433.             execl("/usr/bin/remsh", "remsh", system, "-l", login,
  434.                 "/etc/rmt", (char *) 0);
  435.         }
  436.         else
  437.         {
  438.             execl("/usr/ucb/rsh", "rsh", system,
  439.                 "/etc/rmt", (char *) 0);
  440.             execl("/usr/bin/remsh", "remsh", system,
  441.                 "/etc/rmt", (char *) 0);
  442.         }
  443.  
  444. /*
  445.  *    bad problems if we get here
  446.  */
  447.  
  448.         perror("exec");
  449.         exit(1);
  450.     }
  451.  
  452.     close(Ptc[i][0]); close(Ctp[i][1]);
  453.  
  454. /*
  455.  *    now attempt to open the tape device
  456.  */
  457.  
  458.     sprintf(buffer, "O%s\n%d\n", device, oflag);
  459.     if (command(i, buffer) == -1 || status(i) == -1)
  460.         return(-1);
  461.  
  462.     return(i);
  463. }
  464.  
  465.  
  466.  
  467. /*
  468.  *    _rmt_close --- close a remote magtape unit and shut down
  469.  */
  470.  
  471. static int _rmt_close(fildes)
  472. int fildes;
  473. {
  474.     int rc;
  475.  
  476.     if (command(fildes, "C\n") != -1)
  477.     {
  478.         rc = status(fildes);
  479.  
  480.         abort(fildes);
  481.         return(rc);
  482.     }
  483.  
  484.     return(-1);
  485. }
  486.  
  487.  
  488.  
  489. /*
  490.  *    _rmt_read --- read a buffer from a remote tape
  491.  */
  492.  
  493. static int _rmt_read(fildes, buf, nbyte)
  494. int fildes;
  495. char *buf;
  496. unsigned int nbyte;
  497. {
  498.     int rc, i;
  499.     char buffer[BUFMAGIC];
  500.  
  501.     sprintf(buffer, "R%d\n", nbyte);
  502.     if (command(fildes, buffer) == -1 || (rc = status(fildes)) == -1)
  503.         return(-1);
  504.  
  505.     for (i = 0; i < rc; i += nbyte, buf += nbyte)
  506.     {
  507.         nbyte = read(READ(fildes), buf, rc);
  508.         if (nbyte <= 0)
  509.         {
  510.             abort(fildes);
  511.             errno = EIO;
  512.             return(-1);
  513.         }
  514.     }
  515.  
  516.     return(rc);
  517. }
  518.  
  519.  
  520.  
  521. /*
  522.  *    _rmt_write --- write a buffer to the remote tape
  523.  */
  524.  
  525. static int _rmt_write(fildes, buf, nbyte)
  526. int fildes;
  527. char *buf;
  528. unsigned int nbyte;
  529. {
  530.     int rc;
  531.     char buffer[BUFMAGIC];
  532.     int (*pstat)();
  533.  
  534.     sprintf(buffer, "W%d\n", nbyte);
  535.     if (command(fildes, buffer) == -1)
  536.         return(-1);
  537.  
  538.     pstat = signal(SIGPIPE, SIG_IGN);
  539.     if (write(WRITE(fildes), buf, nbyte) == nbyte)
  540.     {
  541.         signal (SIGPIPE, pstat);
  542.         return(status(fildes));
  543.     }
  544.  
  545.     signal (SIGPIPE, pstat);
  546.     abort(fildes);
  547.     errno = EIO;
  548.     return(-1);
  549. }
  550.  
  551.  
  552.  
  553. /*
  554.  *    _rmt_lseek --- perform an imitation lseek operation remotely
  555.  */
  556.  
  557. static long _rmt_lseek(fildes, offset, whence)
  558. int fildes;
  559. long offset;
  560. int whence;
  561. {
  562.     char buffer[BUFMAGIC];
  563.  
  564.     sprintf(buffer, "L%d\n%d\n", offset, whence);
  565.     if (command(fildes, buffer) == -1)
  566.         return(-1);
  567.  
  568.     return(status(fildes));
  569. }
  570.  
  571.  
  572. /*
  573.  *    _rmt_ioctl --- perform raw tape operations remotely
  574.  */
  575.  
  576. #ifdef RMTIOCTL
  577. static _rmt_ioctl(fildes, op, arg)
  578. int fildes, op;
  579. char *arg;
  580. {
  581.     char c;
  582.     int rc, cnt;
  583.     char buffer[BUFMAGIC];
  584.  
  585. /*
  586.  *    MTIOCOP is the easy one. nothing is transfered in binary
  587.  */
  588.  
  589.     if (op == MTIOCTOP)
  590.     {
  591.         sprintf(buffer, "I%d\n%d\n", ((struct mtop *) arg)->mt_op,
  592.             ((struct mtop *) arg)->mt_count);
  593.         if (command(fildes, buffer) == -1)
  594.             return(-1);
  595.         return(status(fildes));
  596.     }
  597.  
  598. /*
  599.  *    we can only handle 2 ops, if not the other one, punt
  600.  */
  601.  
  602.     if (op != MTIOCGET)
  603.     {
  604.         errno = EINVAL;
  605.         return(-1);
  606.     }
  607.  
  608. /*
  609.  *    grab the status and read it directly into the structure
  610.  *    this assumes that the status buffer is (hopefully) not
  611.  *    padded and that 2 shorts fit in a long without any word
  612.  *    alignment problems, ie - the whole struct is contiguous
  613.  *    NOTE - this is probably NOT a good assumption.
  614.  */
  615.  
  616.     if (command(fildes, "S\n") == -1 || (rc = status(fildes)) == -1)
  617.         return(-1);
  618.  
  619.     for (; rc > 0; rc -= cnt, arg += cnt)
  620.     {
  621.         cnt = read(READ(fildes), arg, rc);
  622.         if (cnt <= 0)
  623.         {
  624.             abort(fildes);
  625.             errno = EIO;
  626.             return(-1);
  627.         }
  628.     }
  629.  
  630. /*
  631.  *    now we check for byte position. mt_type is a small integer field
  632.  *    (normally) so we will check its magnitude. if it is larger than
  633.  *    256, we will assume that the bytes are swapped and go through
  634.  *    and reverse all the bytes
  635.  */
  636.  
  637.     if (((struct mtget *) arg)->mt_type < 256)
  638.         return(0);
  639.  
  640.     for (cnt = 0; cnt < rc; cnt += 2)
  641.     {
  642.         c = arg[cnt];
  643.         arg[cnt] = arg[cnt+1];
  644.         arg[cnt+1] = c;
  645.     }
  646.  
  647.     return(0);
  648.   }
  649. #endif /* RMTIOCTL */
  650.  
  651. /*
  652.  *    Added routines to replace open(), close(), lseek(), ioctl(), etc.
  653.  *    The preprocessor can be used to remap these the rmtopen(), etc
  654.  *    thus minimizing source changes:
  655.  *
  656.  *        #ifdef <something>
  657.  *        #  define access rmtaccess
  658.  *        #  define close rmtclose
  659.  *        #  define creat rmtcreat
  660.  *        #  define dup rmtdup
  661.  *        #  define fcntl rmtfcntl
  662.  *        #  define fstat rmtfstat
  663.  *        #  define ioctl rmtioctl
  664.  *        #  define isatty rmtisatty
  665.  *        #  define lseek rmtlseek
  666.  *        #  define lstat rmtlstat
  667.  *        #  define open rmtopen
  668.  *        #  define read rmtread
  669.  *        #  define stat rmtstat
  670.  *        #  define write rmtwrite
  671.  *        #  define access rmtaccess
  672.  *        #  define close rmtclose
  673.  *        #  define creat rmtcreat
  674.  *        #  define dup rmtdup
  675.  *        #  define fcntl rmtfcntl
  676.  *        #  define fstat rmtfstat
  677.  *        #  define ioctl rmtioctl
  678.  *        #  define lseek rmtlseek
  679.  *        #  define open rmtopen
  680.  *        #  define read rmtread
  681.  *        #  define stat rmtstat
  682.  *        #  define write rmtwrite
  683.  *        #endif
  684.  *
  685.  *    -- Fred Fish
  686.  *
  687.  *    ADR --- I set up a <rmt.h> include file for this
  688.  *
  689.  */
  690.  
  691. /*
  692.  *    Note that local vs remote file descriptors are distinquished
  693.  *    by adding a bias to the remote descriptors.  This is a quick
  694.  *    and dirty trick that may not be portable to some systems.
  695.  */
  696.  
  697. #define REM_BIAS 128
  698.  
  699.  
  700. /*
  701.  *    Test pathname to see if it is local or remote.  A remote device
  702.  *    is any string that contains ":/dev/".  Returns 1 if remote,
  703.  *    0 otherwise.
  704.  */
  705.  
  706. static int remdev (path)
  707. register char *path;
  708. {
  709. #define strchr    index
  710.     extern char *strchr ();
  711.  
  712.     if ((path = strchr (path, ':')) != NULL)
  713.     {
  714.         if (strncmp (path + 1, "/dev/", 5) == 0)
  715.         {
  716.             return (1);
  717.         }
  718.     }
  719.     return (0);
  720. }
  721.  
  722.  
  723. /*
  724.  *    Open a local or remote file.  Looks just like open(2) to
  725.  *    caller.
  726.  */
  727.  
  728. int rmtopen (path, oflag, mode)
  729. char *path;
  730. int oflag;
  731. int mode;
  732. {
  733.     if (remdev (path))
  734.     {
  735.         return (_rmt_open (path, oflag, mode) + REM_BIAS);
  736.     }
  737.     else
  738.     {
  739.         return (open (path, oflag, mode));
  740.     }
  741. }
  742.  
  743. /*
  744.  *    Test pathname for specified access.  Looks just like access(2)
  745.  *    to caller.
  746.  */
  747.  
  748. int rmtaccess (path, amode)
  749. char *path;
  750. int amode;
  751. {
  752.     if (remdev (path))
  753.     {
  754.         return (0);        /* Let /etc/rmt find out */
  755.     }
  756.     else
  757.     {
  758.         return (access (path, amode));
  759.     }
  760. }
  761.  
  762.  
  763. /*
  764.  *    Read from stream.  Looks just like read(2) to caller.
  765.  */
  766.   
  767. int rmtread (fildes, buf, nbyte)
  768. int fildes;
  769. char *buf;
  770. unsigned int nbyte;
  771. {
  772.     if (isrmt (fildes))
  773.     {
  774.         return (_rmt_read (fildes - REM_BIAS, buf, nbyte));
  775.     }
  776.     else
  777.     {
  778.         return (read (fildes, buf, nbyte));
  779.     }
  780. }
  781.  
  782.  
  783. /*
  784.  *    Write to stream.  Looks just like write(2) to caller.
  785.  */
  786.  
  787. int rmtwrite (fildes, buf, nbyte)
  788. int fildes;
  789. char *buf;
  790. unsigned int nbyte;
  791. {
  792.     if (isrmt (fildes))
  793.     {
  794.         return (_rmt_write (fildes - REM_BIAS, buf, nbyte));
  795.     }
  796.     else
  797.     {
  798.         return (write (fildes, buf, nbyte));
  799.     }
  800. }
  801.  
  802. /*
  803.  *    Perform lseek on file.  Looks just like lseek(2) to caller.
  804.  */
  805.  
  806. long rmtlseek (fildes, offset, whence)
  807. int fildes;
  808. long offset;
  809. int whence;
  810. {
  811.     if (isrmt (fildes))
  812.     {
  813.         return (_rmt_lseek (fildes - REM_BIAS, offset, whence));
  814.     }
  815.     else
  816.     {
  817.         return (lseek (fildes, offset, whence));
  818.     }
  819. }
  820.  
  821.  
  822. /*
  823.  *    Close a file.  Looks just like close(2) to caller.
  824.  */
  825.  
  826. int rmtclose (fildes)
  827. int fildes;
  828. {
  829.     if (isrmt (fildes))
  830.     {
  831.         return (_rmt_close (fildes - REM_BIAS));
  832.     }
  833.     else
  834.     {
  835.         return (close (fildes));
  836.     }
  837. }
  838.  
  839. /*
  840.  *    Do ioctl on file.  Looks just like ioctl(2) to caller.
  841.  */
  842.  
  843. int rmtioctl (fildes, request, arg)
  844. int fildes, request, arg;
  845. {
  846.     if (isrmt (fildes))
  847.     {
  848. #ifdef RMTIOCTL
  849.         return (_rmt_ioctl (fildes, request, arg));
  850. #else
  851.         errno = EOPNOTSUPP;
  852.         return (-1);        /* For now  (fnf) */
  853. #endif
  854.     }
  855.     else
  856.     {
  857.         return (ioctl (fildes, request, arg));
  858.     }
  859. }
  860.  
  861.  
  862. /*
  863.  *    Duplicate an open file descriptor.  Looks just like dup(2)
  864.  *    to caller.
  865.  */
  866.  
  867. int rmtdup (fildes)
  868. int fildes;
  869. {
  870.     if (isrmt (fildes))
  871.     {
  872.         errno = EOPNOTSUPP;
  873.         return (-1);        /* For now (fnf) */
  874.     }
  875.     else
  876.     {
  877.         return (dup (fildes));
  878.     }
  879. }
  880.  
  881. /*
  882.  *    Get file status.  Looks just like fstat(2) to caller.
  883.  */
  884.  
  885. int rmtfstat (fildes, buf)
  886. int fildes;
  887. struct stat *buf;
  888. {
  889.     if (isrmt (fildes))
  890.     {
  891.         errno = EOPNOTSUPP;
  892.         return (-1);        /* For now (fnf) */
  893.     }
  894.     else
  895.     {
  896.         return (fstat (fildes, buf));
  897.     }
  898. }
  899.  
  900.  
  901. /*
  902.  *    Get file status.  Looks just like stat(2) to caller.
  903.  */
  904.  
  905. int rmtstat (path, buf)
  906. char *path;
  907. struct stat *buf;
  908. {
  909.     if (remdev (path))
  910.     {
  911.         errno = EOPNOTSUPP;
  912.         return (-1);        /* For now (fnf) */
  913.     }
  914.     else
  915.     {
  916.         return (stat (path, buf));
  917.     }
  918. }
  919.  
  920.  
  921.  
  922. /*
  923.  *    Create a file from scratch.  Looks just like creat(2) to the caller.
  924.  */
  925.  
  926. #include <sys/file.h>        /* BSD DEPENDANT!!! */
  927. /* #include <fcntl.h>        /* use this one for S5 with remote stuff */
  928.  
  929. int rmtcreat (path, mode)
  930. char *path;
  931. int mode;
  932. {
  933.     if (remdev (path))
  934.     {
  935.         return (rmtopen (path, 1 | O_CREAT, mode));
  936.     }
  937.     else
  938.     {
  939.         return (creat (path, mode));
  940.     }
  941. }
  942.  
  943. /*
  944.  *    Isrmt. Let a programmer know he has a remote device.
  945.  */
  946.  
  947. int isrmt (fd)
  948. int fd;
  949. {
  950.     return (fd >= REM_BIAS);
  951. }
  952.  
  953. /*
  954.  *    Rmtfcntl. Do a remote fcntl operation.
  955.  */
  956.  
  957. int rmtfcntl (fd, cmd, arg)
  958. int fd, cmd, arg;
  959. {
  960.     if (isrmt (fd))
  961.     {
  962.         errno = EOPNOTSUPP;
  963.         return (-1);
  964.     }
  965.     else
  966.     {
  967.         return (fcntl (fd, cmd, arg));
  968.     }
  969. }
  970.  
  971. /*
  972.  *    Rmtisatty.  Do the isatty function.
  973.  */
  974.  
  975. int rmtisatty (fd)
  976. int fd;
  977. {
  978.     if (isrmt (fd))
  979.         return (0);
  980.     else
  981.         return (isatty (fd));
  982. }
  983.  
  984.  
  985. /*
  986.  *    Get file status, even if symlink.  Looks just like lstat(2) to caller.
  987.  */
  988.  
  989. int rmtlstat (path, buf)
  990. char *path;
  991. struct stat *buf;
  992. {
  993.     if (remdev (path))
  994.     {
  995.         errno = EOPNOTSUPP;
  996.         return (-1);        /* For now (fnf) */
  997.     }
  998.     else
  999.     {
  1000.         return (lstat (path, buf));
  1001.     }
  1002. }
  1003. SHAR_EOF
  1004. fi # end of overwriting check
  1005. echo shar: extracting "'rmtops.3'" '(4477 characters)'
  1006. if test -f 'rmtops.3'
  1007. then
  1008.     echo shar: will not over-write existing file "'rmtops.3'"
  1009. else
  1010. cat << \SHAR_EOF > 'rmtops.3'
  1011. ...
  1012. ... $Header: rmtops.3,v 1.2 86/10/09 16:38:02 root Locked $
  1013. ... 
  1014. ... $Log:    rmtops.3,v $
  1015. ... Revision 1.2  86/10/09  16:38:02  root
  1016. ... Changed to reflect 4.3BSD rcp syntax and better rmt(8) capabilities. ADR.
  1017. ... 
  1018. ... Revision 1.1  86/10/09  16:18:47  root
  1019. ... Initial revision
  1020. ... 
  1021. ...
  1022. .TH RMTOPS 3 local
  1023. .SH NAME
  1024. rmtops \- access tape drives on remote machines
  1025. .SH SYNOPSIS
  1026. .nf
  1027. #include <rmt.h>
  1028. #include <sys/stat.h>    /* MUST come after <rmt.h> */
  1029.  
  1030. int isrmt (fd)
  1031. int fd;
  1032.  
  1033. int rmtaccess (file, mode)
  1034. char *file;
  1035. int mode;
  1036.  
  1037. int rmtclose (fd)
  1038. int fd;
  1039.  
  1040. int rmtcreat (file, mode)
  1041. char *file;
  1042. int mode;
  1043.  
  1044. int rmtdup (fd)
  1045. int fd;
  1046.  
  1047. int rmtfcntl (fd, cmd, arg)
  1048. int fd, cmd, arg;
  1049.  
  1050. int rmtfstat (fd, buf)
  1051. int fd;
  1052. struct stat *buf;
  1053.  
  1054. int rmtioctl (fd, request, argp)
  1055. int fd, request;
  1056. char *argp;
  1057.  
  1058. int rmtisatty (fd)
  1059. int fd;
  1060.  
  1061. long rmtlseek (fd, offset, whence)
  1062. int fd, whence;
  1063. long offset;
  1064.  
  1065. int rmtlstat (file, buf)
  1066. char *file;
  1067. struct stat *buf;
  1068.  
  1069. int rmtopen (file, flags [, mode])
  1070. char *file;
  1071. int flags, mode;
  1072.  
  1073. int rmtread (fd, buf, nbytes)
  1074. int fd, nbytes;
  1075. char *buf;
  1076.  
  1077. int rmtstat (file, buf)
  1078. char *file;
  1079. struct stat *buf;
  1080.  
  1081. int rmtwrite (fd, buf, nbytes)
  1082. int fd, nbytes;
  1083. char *buf;
  1084. .fi
  1085. .SH DESCRIPTION
  1086. .I Rmtops
  1087. provides a simple means of transparently accessing tape drives
  1088. on remote machines over the ethernet, via
  1089. .IR rsh (1)
  1090. and
  1091. .IR rmt (8).
  1092. These routines are used like their corresponding
  1093. system calls, but allow the user to open up a tape drive on a remote
  1094. system on which he or she has an account and the appropriate remote
  1095. permissions.
  1096. .PP
  1097. A remote tape drive file name has either of the forms
  1098. .sp
  1099. .RS
  1100. .RI [ user @] system :/dev/???
  1101. .RE
  1102. .sp
  1103. or
  1104. .sp
  1105. .RS
  1106. .IR system [. user ]:/dev/???
  1107. .RE
  1108. .sp
  1109. where
  1110. .I system
  1111. is the remote system,
  1112. .I /dev/???
  1113. is the particular drive on the remote system (raw, blocked, rewinding,
  1114. non-rewinding, etc.), and the optional
  1115. .I user
  1116. is the login name to be used on the remote system, if different from
  1117. the current user's login name.
  1118. The first form corresponds to the remote syntax used by
  1119. .IR rcp (1)
  1120. in 4.3BSD, the second form is for compatibility with
  1121. .IR rcp 's
  1122. syntax in 4.2BSD.
  1123. .PP
  1124. For transparency, the user should include the file
  1125. .IR <rmt.h> ,
  1126. which has the following defines in it:
  1127. .PP
  1128. .nf
  1129. #define access rmtaccess
  1130. #define close rmtclose
  1131. #define creat rmtcreat
  1132. #define dup rmtdup
  1133. #define fcntl rmtfcntl
  1134. #define fstat rmtfstat
  1135. #define ioctl rmtioctl
  1136. #define isatty rmtisatty
  1137. #define lseek rmtlseek
  1138. #define lstat rmtlstat
  1139. #define open rmtopen
  1140. #define read rmtread
  1141. #define stat rmtstat
  1142. #define write rmtwrite
  1143. .fi
  1144. .PP
  1145. This allows the programmer to use
  1146. .IR open ,
  1147. .IR close ,
  1148. .IR read ,
  1149. .IR write ,
  1150. etc. in their normal fashion, with the
  1151. .I rmtops
  1152. routines taking care of differentiating between local and remote files.
  1153. This file should be included
  1154. .I before
  1155. including the file
  1156. .IR <sys/stat.h> ,
  1157. since it redefines the identifier ``stat,'' which is used to declare
  1158. objects of type struct stat.
  1159. .PP
  1160. The routines differentiate between local and remote file descriptors by
  1161. adding a bias (currently 128) to the file descriptor of the pipe.
  1162. The programmer, if he must know if a file is remote, should use the
  1163. .I isrmt
  1164. function.
  1165. .SH FILES
  1166. .TP
  1167. .B /usr/lib/librmt.a
  1168. Contains the remote tape library.  To include the library with a program,
  1169. add the flag
  1170. .B \-lrmt
  1171. to the
  1172. .IR cc (1)
  1173. command line.
  1174. .SH SEE ALSO
  1175. .IR rcp (1),
  1176. .IR rsh (1),
  1177. .IR rmt (8),
  1178. and the appropriate system calls in section 2.
  1179. .SH DIAGNOSTICS
  1180. Several of these routines will return -1 and set
  1181. .I errno
  1182. to EOPNOTSUPP, if they are given a remote file name or a file descriptor
  1183. on an open remote file (e.g.,
  1184. .IR rmtdup ).
  1185. .SH BUGS
  1186. See diagnostics above.  It is to be hoped that true remote file systems
  1187. will eventually appear, and eliminate the need for these routines.
  1188. .PP
  1189. There is no way to use remote tape drives with the
  1190. .IR stdio (3)
  1191. package, short of recompiling it entirely to use these routines.
  1192. .PP
  1193. The
  1194. .IR rmt (8)
  1195. protocol is not very capable.  In particular, it relies on
  1196. TCP/IP sockets for error free transmission, and does no data validation
  1197. of its own.
  1198. .SH AUTHORS
  1199. Jeff Lee (gatech!jeff) wrote the original routines for accessing
  1200. tape drives via
  1201. .IR rmt (8).
  1202. .PP
  1203. Fred Fish (unisoft!fnf) redid them into a general purpose library.
  1204. .PP
  1205. Arnold Robbins
  1206. (formerly gatech!arnold, now emory!arnold)
  1207. added the ability to specify a user
  1208. name on the remote system, the
  1209. .I <rmt.h>
  1210. include file, this man page,
  1211. cleaned up the library a little,
  1212. and made the appropriate changes for 4.3BSD.
  1213. SHAR_EOF
  1214. fi # end of overwriting check
  1215. echo shar: extracting "'dd.1.patch'" '(1933 characters)'
  1216. if test -f 'dd.1.patch'
  1217. then
  1218.     echo shar: will not over-write existing file "'dd.1.patch'"
  1219. else
  1220. cat << \SHAR_EOF > 'dd.1.patch'
  1221. RCS file: RCS/dd.1,v
  1222. retrieving revision 1.1
  1223. diff -c -r1.1 dd.1
  1224. *** /tmp/,RCSt1012245    Thu Oct  9 16:50:49 1986
  1225. --- dd.1    Thu Oct  9 16:50:18 1986
  1226. ***************
  1227. *** 1,7 ****
  1228.   ...
  1229. ! ... $Header: dd.1,v 1.1 86/08/07 16:02:52 root Exp $
  1230.   ... 
  1231.   ... $Log:    dd.1,v $
  1232.   ... Revision 1.1  86/08/07  16:02:52  root
  1233.   ... Initial revision
  1234.   ... 
  1235. --- 1,13 ----
  1236.   ...
  1237. ! ... $Header: dd.1,v 1.3 86/10/09 16:50:02 root Locked $
  1238.   ... 
  1239.   ... $Log:    dd.1,v $
  1240. + ... Revision 1.3  86/10/09  16:50:02  root
  1241. + ... Changed to indicate use of 4.3 rcp syntax. ADR.
  1242. + ... 
  1243. + ... Revision 1.2  86/08/07  16:05:53  root
  1244. + ... Added doc of remote mag tape facility. ADR.
  1245. + ... 
  1246.   ... Revision 1.1  86/08/07  16:02:52  root
  1247.   ... Initial revision
  1248.   ... 
  1249. ***************
  1250. *** 38,48 ****
  1251.   .TP 
  1252.   if=
  1253.   input file name; standard input is default
  1254.   .br
  1255.   .ns
  1256.   .TP 
  1257.   of=
  1258. ! output file name; standard output is default
  1259.   .br
  1260.   .ns
  1261.   .TP 
  1262. --- 44,76 ----
  1263.   .TP 
  1264.   if=
  1265.   input file name; standard input is default
  1266. + If the input file name has either of the forms
  1267. + .RI [ user @] system :/dev/???,
  1268. + or
  1269. + .IR system [. user ]:/dev/???,
  1270. + then
  1271. + .I dd
  1272. + will attempt to use the tape drive /dev/??? on the remote system
  1273. + .IR system ,
  1274. + via
  1275. + .IR rsh (1),
  1276. + and
  1277. + .IR rmt (8).
  1278. + The optional
  1279. + .I user
  1280. + specifies the login name to use on the remote system.
  1281. + If it is not given, the current user's login name will be used.
  1282. + In all cases, the user must have the appropriate
  1283. + access permissions on the remote machine in order for this to work.
  1284. + (The first form is the 4.3BSD syntax for
  1285. + .IR rcp (1),
  1286. + the second is from 4.2BSD.)
  1287.   .br
  1288.   .ns
  1289.   .TP 
  1290.   of=
  1291. ! output file name; standard output is default,
  1292. ! remote file names may be used here as well.
  1293.   .br
  1294.   .ns
  1295.   .TP 
  1296. ***************
  1297. *** 233,235 ****
  1298. --- 261,265 ----
  1299.   Invalid combinations
  1300.   .I "silently ignore"
  1301.   all but the last mutually-exclusive keyword.
  1302. + .br
  1303. + Using a remote system's tape drive can be slow.
  1304. SHAR_EOF
  1305. fi # end of overwriting check
  1306. echo shar: extracting "'dd.c.patch'" '(871 characters)'
  1307. if test -f 'dd.c.patch'
  1308. then
  1309.     echo shar: will not over-write existing file "'dd.c.patch'"
  1310. else
  1311. cat << \SHAR_EOF > 'dd.c.patch'
  1312. RCS file: RCS/dd.c,v
  1313. retrieving revision 1.1
  1314. diff -c -r1.1 dd.c
  1315. *** /tmp/,RCSt1011946    Thu Oct  9 16:44:54 1986
  1316. --- dd.c    Thu Aug  7 15:55:33 1986
  1317. ***************
  1318. *** 1,9 ****
  1319.   #ifndef lint
  1320. ! static char *RCSid = "$Header: dd.c,v 1.1 86/08/07 15:52:39 root Exp $";
  1321.   #endif
  1322.   
  1323.   /*
  1324.    * $Log:    dd.c,v $
  1325.    * Revision 1.1  86/08/07  15:52:39  root
  1326.    * Initial revision
  1327.    * 
  1328. --- 1,12 ----
  1329.   #ifndef lint
  1330. ! static char *RCSid = "$Header: dd.c,v 1.2 86/08/07 15:55:17 root Locked $";
  1331.   #endif
  1332.   
  1333.   /*
  1334.    * $Log:    dd.c,v $
  1335. +  * Revision 1.2  86/08/07  15:55:17  root
  1336. +  * Added remote mag tape capability. ADR.
  1337. +  * 
  1338.    * Revision 1.1  86/08/07  15:52:39  root
  1339.    * Initial revision
  1340.    * 
  1341. ***************
  1342. *** 15,20 ****
  1343. --- 18,24 ----
  1344.   
  1345.   #include <stdio.h>
  1346.   #include <signal.h>
  1347. + #include <rmt.h>    /* remote mag tape library */
  1348.   
  1349.   #define    BIG    2147483647
  1350.   #define    LCASE    01
  1351. SHAR_EOF
  1352. fi # end of overwriting check
  1353. echo shar: extracting "'tar.1.patch'" '(2168 characters)'
  1354. if test -f 'tar.1.patch'
  1355. then
  1356.     echo shar: will not over-write existing file "'tar.1.patch'"
  1357. else
  1358. cat << \SHAR_EOF > 'tar.1.patch'
  1359. RCS file: RCS/tar.1,v
  1360. retrieving revision 1.1
  1361. diff -c -r1.1 tar.1
  1362. *** /tmp/,RCSt1012257    Thu Oct  9 16:51:06 1986
  1363. --- tar.1    Thu Oct  9 16:50:23 1986
  1364. ***************
  1365. *** 1,7 ****
  1366.   ...
  1367. ! ... $Header: tar.1,v 1.1 86/08/07 16:02:56 root Exp $
  1368.   ... 
  1369.   ... $Log:    tar.1,v $
  1370.   ... Revision 1.1  86/08/07  16:02:56  root
  1371.   ... Initial revision
  1372.   ... 
  1373. --- 1,13 ----
  1374.   ...
  1375. ! ... $Header: tar.1,v 1.3 86/10/09 16:50:19 root Locked $
  1376.   ... 
  1377.   ... $Log:    tar.1,v $
  1378. + ... Revision 1.3  86/10/09  16:50:19  root
  1379. + ... Changed to indicate use of 4.3 rcp syntax. ADR.
  1380. + ... 
  1381. + ... Revision 1.2  86/08/07  16:05:34  root
  1382. + ... Added doc of remote mag tape facility. ADR.
  1383. + ... 
  1384.   ... Revision 1.1  86/08/07  16:02:56  root
  1385.   ... Initial revision
  1386.   ... 
  1387. ***************
  1388. *** 106,112 ****
  1389.   .B f
  1390.   .I Tar
  1391.   uses the next argument as the name of the archive instead of
  1392. ! /dev/rmt?. If the name of the file is `\-', tar writes to standard output or
  1393.   reads from standard input, whichever is appropriate. Thus,
  1394.   .I tar
  1395.   can be used as the head or tail of a filter chain.
  1396. --- 112,142 ----
  1397.   .B f
  1398.   .I Tar
  1399.   uses the next argument as the name of the archive instead of
  1400. ! /dev/rmt?.
  1401. ! .sp
  1402. ! If the file name has either of the forms
  1403. ! .RI [ user @] system :/dev/???,
  1404. ! or
  1405. ! .IR system [. user ]:/dev/???,
  1406. ! .I tar
  1407. ! will use the tape drive /dev/??? on the remote system
  1408. ! .IR system ,
  1409. ! via
  1410. ! .IR rsh (1),
  1411. ! and
  1412. ! .IR rmt (8).
  1413. ! The optional
  1414. ! .I user
  1415. ! portion of the pathname specifies the login name to use on the
  1416. ! remote system.
  1417. ! If it is not supplied, the current user's login name will be used.
  1418. ! In all the cases, the user must have the appropriate
  1419. ! permissions on the remote machine, in order to use this facility.
  1420. ! (The first form is the 4.3BSD syntax for
  1421. ! .IR rcp (1),
  1422. ! the second is from 4.2BSD.)
  1423. ! .sp
  1424. ! If the name of the file is `\-', tar writes to standard output or
  1425.   reads from standard input, whichever is appropriate. Thus,
  1426.   .I tar
  1427.   can be used as the head or tail of a filter chain.
  1428. ***************
  1429. *** 199,201 ****
  1430. --- 229,233 ----
  1431.   or
  1432.   .B u
  1433.   options, directory modification times may not be set correctly.
  1434. + .br
  1435. + Using a remote system's tape drive can be slow.
  1436. SHAR_EOF
  1437. fi # end of overwriting check
  1438. echo shar: extracting "'tar.c.patch'" '(911 characters)'
  1439. if test -f 'tar.c.patch'
  1440. then
  1441.     echo shar: will not over-write existing file "'tar.c.patch'"
  1442. else
  1443. cat << \SHAR_EOF > 'tar.c.patch'
  1444. RCS file: RCS/tar.c,v
  1445. retrieving revision 1.1
  1446. diff -c -r1.1 tar.c
  1447. *** /tmp/,RCSt1011918    Thu Oct  9 16:44:38 1986
  1448. --- tar.c    Thu Aug  7 16:00:55 1986
  1449. ***************
  1450. *** 1,9 ****
  1451.   #ifndef lint
  1452. ! static char *RCSid = "$Header: tar.c,v 1.1 86/08/07 15:52:50 root Exp $";
  1453.   #endif
  1454.   
  1455.   /*
  1456.    * $Log:    tar.c,v $
  1457.    * Revision 1.1  86/08/07  15:52:50  root
  1458.    * Initial revision
  1459.    * 
  1460. --- 1,12 ----
  1461.   #ifndef lint
  1462. ! static char *RCSid = "$Header: tar.c,v 1.2 86/08/07 16:00:34 root Locked $";
  1463.   #endif
  1464.   
  1465.   /*
  1466.    * $Log:    tar.c,v $
  1467. +  * Revision 1.2  86/08/07  16:00:34  root
  1468. +  * Added remote mag tape capability. ADR.
  1469. +  * 
  1470.    * Revision 1.1  86/08/07  15:52:50  root
  1471.    * Initial revision
  1472.    * 
  1473. ***************
  1474. *** 29,34 ****
  1475. --- 32,38 ----
  1476.    * Tape Archival Program
  1477.    */
  1478.   #include <stdio.h>
  1479. + #include <rmt.h>    /* remote mag tape library */
  1480.   #include <sys/param.h>
  1481.   #include <sys/stat.h>
  1482.   #include <sys/dir.h>
  1483. SHAR_EOF
  1484. fi # end of overwriting check
  1485. #    End of shell archive
  1486. exit 0
  1487.  
  1488.